/**
 * 购物车缓存管理器 - 服务器优先模式
 * 主要以接口查询为主，本地存储只作为接口报错场景下的备份使用
 */

import cartApi from '../request/cart.js'
import authManager from './auth.js'

const CART_STORAGE_KEY = 'shopping_cart'

class CartManager {
    constructor() {
        this.cartData = this.loadLocalCart() // 只加载本地缓存，不作为主要数据源
        this.listeners = [] // 监听器列表，用于通知页面更新
        this.isOnline = true // 网络状态标识
        this.lastNetworkError = null // 最后一次网络错误
    }

    /**
     * 从本地存储加载购物车数据（仅用作备份）
     */
    loadLocalCart() {
        try {
            const cartStr = uni.getStorageSync(CART_STORAGE_KEY)
            if (cartStr) {
                return JSON.parse(cartStr)
            }
        } catch (error) {
            console.error('加载本地购物车数据失败:', error)
        }
        return {
            items: [],
            totalAmount: 0,
            totalQuantity: 0,
            lastSyncTime: 0
        }
    }

    /**
     * 保存购物车数据到本地存储（备份）
     */
    saveLocalCart() {
        try {
            this.cartData.lastSyncTime = Date.now()
            uni.setStorageSync(CART_STORAGE_KEY, JSON.stringify(this.cartData))
        } catch (error) {
            console.error('保存本地购物车数据失败:', error)
        }
    }

    /**
     * 检查是否需要登录
     */
    isLoggedIn() {
        return authManager.isLoggedIn()
    }

    /**
     * 从服务器加载购物车数据（主要数据源）
     */
    async loadCart() {
        if (!this.isLoggedIn()) {
            console.log('用户未登录，返回空购物车')
            this.cartData = {
                items: [],
                totalAmount: 0,
                totalQuantity: 0,
                lastSyncTime: 0
            }
            this.notifyListeners()
            return this.cartData
        }

        try {
            const serverCartData = await cartApi.getCartList()
            
            // 转换服务器数据格式为本地格式
            const serverItems = this.convertServerDataToLocal(serverCartData)
            
            this.cartData = {
                items: serverItems,
                totalAmount: 0,
                totalQuantity: 0,
                lastSyncTime: Date.now()
            }
            
            this.updateTotals()
            this.saveLocalCart() // 备份到本地
            this.isOnline = true
            this.lastNetworkError = null
            
            console.log('从服务器加载购物车数据成功')
            this.notifyListeners()
            return this.cartData

        } catch (error) {
            console.error('从服务器加载购物车数据失败:', error)
            this.isOnline = false
            this.lastNetworkError = error
            
            // 服务器失败时使用本地缓存
            console.log('服务器加载失败，使用本地缓存数据')
            this.notifyListeners()
            return this.cartData
        }
    }

    /**
     * 添加商品到购物车 - 服务器优先
     * @param {Object} product 商品信息
     * @param {string} product.id 商品ID
     * @param {string} product.name 商品名称
     * @param {number} quantity 数量，默认1
     * @param {Object} spec 商品规格（可选）
     */
    async addItem(product, quantity = 1, spec = null) {
        if (!product || !product.id) {
            throw new Error('商品信息不完整')
        }

        if (!this.isLoggedIn()) {
            throw new Error('请先登录')
        }

        try {
            // 优先使用服务器接口
            const addData = {
                goodsId: product.id,
                quantity: quantity
            }
            
            if (spec) {
                addData.spec = JSON.stringify(spec)
            }

            const serverResult = await cartApi.addToCart(addData)
            
            // 服务器操作成功后，重新加载购物车数据
            await this.loadCart()
            
            this.isOnline = true
            this.lastNetworkError = null
            return true

        } catch (error) {
            console.error('服务器添加商品失败:', error)
            this.isOnline = false
            this.lastNetworkError = error
            
            // 服务器失败时，尝试本地缓存操作
            try {
                const specKey = spec ? JSON.stringify(spec) : ''
                const itemKey = `${product.id}_${specKey}`
                
                const existingItem = this.cartData.items.find(item => item.key === itemKey)
                
                if (existingItem) {
                    existingItem.quantity += quantity
                } else {
                    const newItem = {
                        key: itemKey,
                        id: product.id,
                        goodsName: product.name,
                        quantity: quantity,
                        spec: spec,
                        addTime: Date.now(),
                        serverId: null,
                        synced: false // 标记为未同步，等网络恢复后同步
                    }
                    this.cartData.items.push(newItem)
                }

                this.updateTotals()
                this.saveLocalCart()
                this.notifyListeners()
                
                return true

            } catch (localError) {
                console.error('本地缓存操作也失败:', localError)
                throw new Error('添加商品失败，请检查网络连接')
            }
        }
    }

    /**
     * 从购物车移除商品 - 服务器优先
     * @param {string} itemKey 商品唯一标识
     */
    async removeItem(itemKey) {
        if (!this.isLoggedIn()) {
            throw new Error('请先登录')
        }

        const item = this.cartData.items.find(item => item.key === itemKey)
        if (!item) {
            return false
        }

        try {
            // 如果商品有服务器ID，优先删除服务器数据
            if (item.serverId) {
                await cartApi.deleteItem(item.serverId)
            }

            // 服务器操作成功后，重新加载购物车数据
            await this.loadCart()
            
            this.isOnline = true
            this.lastNetworkError = null
            return true

        } catch (error) {
            console.error('服务器删除商品失败:', error)
            this.isOnline = false
            this.lastNetworkError = error
            
            // 服务器失败时，删除本地数据
            try {
                const index = this.cartData.items.findIndex(item => item.key === itemKey)
                if (index > -1) {
                    this.cartData.items.splice(index, 1)
                    this.updateTotals()
                    this.saveLocalCart()
                    this.notifyListeners()
                    
                    return true
                }
                return false

            } catch (localError) {
                console.error('本地缓存删除也失败:', localError)
                throw new Error('删除商品失败，请检查网络连接')
            }
        }
    }

    /**
     * 更新商品数量 - 服务器优先
     * @param {Object} item 商品信息
     * @param {string} item.id 商品ID
     * @param {number} item.quantity 新数量
     */
    async updateQuantity(product) {
        const {id, quantity} = product

        if (!this.isLoggedIn()) {
            throw new Error('请先登录')
        }

        const item = this.cartData.items.find(item => item.id === id)
        if (!item) {
            return false
        }

        try {
            // 如果商品有服务器ID，优先更新服务器数据
            if (item.serverId) {
                await cartApi.updateQuantity({
                    id: item.serverId,
                    quantity
                })
            }

            // 服务器操作成功后，重新加载购物车数据
            await this.loadCart()
            
            this.isOnline = true
            this.lastNetworkError = null
            return true

        } catch (error) {
            console.error('服务器更新数量失败:', error)
            this.isOnline = false
            this.lastNetworkError = error
            
            // 服务器失败时，更新本地数据
            try {
                item.quantity = quantity
                item.synced = false // 标记为未同步
                this.updateTotals()
                this.saveLocalCart()
                this.notifyListeners()
                
                return true

            } catch (localError) {
                console.error('本地缓存更新也失败:', localError)
                throw new Error('更新数量失败，请检查网络连接')
            }
        }
    }

    /**
     * 获取购物车中的所有商品 - 服务器优先
     */
    async getItems() {
        try {
            await this.loadCart()
            return this.cartData.items
        } catch (error) {
            console.warn('获取服务器数据失败，返回本地缓存:', error)
            return this.cartData.items
        }
    }

    /**
     * 获取购物车数据 - 服务器优先
     */
    async getCartData() {
        try {
            await this.loadCart()
            return { ...this.cartData }
        } catch (error) {
            console.warn('获取服务器数据失败，返回本地缓存:', error)
            return { ...this.cartData }
        }
    }

    /**
     * 获取购物车总数量 - 服务器优先
     */
    getTotalQuantity() {
        try {
            // await this.loadCart()
            console.log('this.cartData :>> ', this.cartData);
            return this.cartData.totalQuantity
        } catch (error) {
            console.warn('获取服务器数据失败，返回本地缓存:', error)
            return this.cartData.totalQuantity
        }
    }

    /**
     * 获取购物车总金额 - 服务器优先
     */
    async getTotalAmount() {
        try {
            await this.loadCart()
            return this.cartData.totalAmount
        } catch (error) {
            console.warn('获取服务器数据失败，返回本地缓存:', error)
            return this.cartData.totalAmount
        }
    }

    /**
     * 检查商品是否在购物车中 - 服务器优先
     * @param {string} productId 商品ID
     * @param {Object} spec 商品规格（可选）
     */
    async isInCart(productId, spec = null) {
        try {
            await this.loadCart()
        } catch (error) {
            console.warn('检查商品状态时服务器失败，使用本地缓存:', error)
        }
        
        const specKey = spec ? JSON.stringify(spec) : ''
        const itemKey = `${productId}_${specKey}`
        return this.cartData.items.some(item => item.key === itemKey)
    }

    /**
     * 获取商品在购物车中的数量 - 服务器优先
     * @param {string} productId 商品ID
     * @param {Object} spec 商品规格（可选）
     */
    async getItemQuantity(productId, spec = null) {
        try {
            await this.loadCart()
        } catch (error) {
            console.warn('获取商品数量时服务器失败，使用本地缓存:', error)
        }
        
        const specKey = spec ? JSON.stringify(spec) : ''
        const itemKey = `${productId}_${specKey}`
        const item = this.cartData.items.find(item => item.key === itemKey)
        return item ? item.quantity : 0
    }

    /**
     * 清空购物车 - 服务器优先
     */
    async clearCart() {
        if (!this.isLoggedIn()) {
            throw new Error('请先登录')
        }

        try {
            // 优先清空服务器数据
            await cartApi.clearCart()
            
            // 服务器操作成功后，清空本地数据
            this.cartData = {
                items: [],
                totalAmount: 0,
                totalQuantity: 0,
                lastSyncTime: Date.now()
            }
            this.saveLocalCart()
            this.notifyListeners()
            
            console.log('购物车已清空')
            this.isOnline = true
            this.lastNetworkError = null
            return true

        } catch (error) {
            console.error('服务器清空失败:', error)
            this.isOnline = false
            this.lastNetworkError = error
            
            // 服务器失败时，清空本地数据
            try {
                this.cartData = {
                    items: [],
                    totalAmount: 0,
                    totalQuantity: 0,
                    lastSyncTime: Date.now()
                }
                this.saveLocalCart()
                this.notifyListeners()
                
                console.log('服务器失败，已清空本地缓存')
                return true

            } catch (localError) {
                console.error('本地缓存清空也失败:', localError)
                throw new Error('清空购物车失败')
            }
        }
    }

    /**
     * 批量选择/取消选择商品
     * @param {Array} itemKeys 商品Key数组
     * @param {boolean} selected 是否选中
     */
    selectItems(itemKeys, selected = true) {
        itemKeys.forEach(itemKey => {
            const item = this.cartData.items.find(item => item.key === itemKey)
            if (item) {
                item.selected = selected
            }
        })
        this.saveLocalCart()
        this.notifyListeners()
    }

    /**
     * 全选/取消全选
     * @param {boolean} selected 是否选中
     */
    selectAll(selected = true) {
        this.cartData.items.forEach(item => {
            item.selected = selected
        })
        this.saveLocalCart()
        this.notifyListeners()
    }

    /**
     * 获取选中的商品
     */
    getSelectedItems() {
        return this.cartData.items.filter(item => item.selected)
    }

    /**
     * 获取选中商品的总数量和总金额
     */
    getSelectedTotals() {
        const selectedItems = this.getSelectedItems()
        const totalQuantity = selectedItems.reduce((total, item) => total + item.quantity, 0)
        const totalAmount = selectedItems.reduce((total, item) => total + (item.goodsPrice * item.quantity), 0)
        
        return {
            totalQuantity,
            totalAmount: parseFloat(totalAmount.toFixed(2))
        }
    }

    /**
     * 用户登录后的数据同步
     */
    async onUserLogin() {
        console.log('用户登录，开始从服务器加载购物车数据')
        
        try {
            // 登录后直接从服务器加载数据
            await this.loadCart()
            console.log('登录后购物车数据加载完成')
        } catch (error) {
            console.error('登录后购物车数据加载失败:', error)
        }
    }

    /**
     * 用户登出后的处理
     */
    onUserLogout() {
        console.log('用户登出，清空购物车数据')
        
        // 清空所有数据
        this.cartData = {
            items: [],
            totalAmount: 0,
            totalQuantity: 0,
            lastSyncTime: 0
        }
        
        this.saveLocalCart()
        this.notifyListeners()
    }

    /**
     * 网络恢复后同步未同步的数据
     */
    async syncPendingData() {
        if (!this.isLoggedIn()) {
            return
        }

        const unsyncedItems = this.cartData.items.filter(item => !item.synced)
        if (unsyncedItems.length === 0) {
            return
        }

        console.log('开始同步未同步的数据...')
        
        try {
            for (const item of unsyncedItems) {
                try {
                    const addData = {
                        goodsId: item.id,
                        quantity: item.quantity
                    }
                    
                    if (item.spec) {
                        addData.spec = JSON.stringify(item.spec)
                    }

                    await cartApi.addToCart(addData)
                } catch (error) {
                    console.warn(`同步商品 ${item.goodsName} 失败:`, error.message)
                }
            }
            
            // 同步完成后重新加载数据
            await this.loadCart()
            console.log('未同步数据同步完成')

        } catch (error) {
            console.error('同步未同步数据失败:', error)
        }
    }

    /**
     * 转换服务器数据格式为本地格式
     */
    convertServerDataToLocal(serverData) {
        if (!Array.isArray(serverData)) {
            return []
        }

        return serverData.map(serverItem => {
            const spec = serverItem.spec ? JSON.parse(serverItem.spec) : null
            const specKey = spec ? JSON.stringify(spec) : ''
            
            return {
                key: `${serverItem.goodsId}_${specKey}`,
                id: serverItem.goodsId,
                goodsName: serverItem.goodsName || serverItem.name,
                goodsPrice: serverItem.goodsPrice,
                listImg: serverItem.listImg || serverItem.image,
                quantity: serverItem.quantity,
                spec: spec,
                addTime: new Date(serverItem.createTime).getTime() || Date.now(),
                serverId: serverItem.id,
                synced: true,
                selected: false // 默认不选中
            }
        })
    }

    /**
     * 更新总计信息
     */
    updateTotals() {
        this.cartData.totalQuantity = this.cartData.items.reduce((total, item) => total + item.quantity, 0)
        this.cartData.totalAmount = this.cartData.items.reduce((total, item) => total + (item.goodsPrice * item.quantity), 0)
        this.cartData.totalAmount = parseFloat(this.cartData.totalAmount.toFixed(2))
    }

    /**
     * 添加监听器
     * @param {Function} listener 监听函数
     */
    addListener(listener) {
        if (typeof listener === 'function' && !this.listeners.includes(listener)) {
            this.listeners.push(listener)
        }
    }

    /**
     * 移除监听器
     * @param {Function} listener 监听函数
     */
    removeListener(listener) {
        const index = this.listeners.indexOf(listener)
        if (index > -1) {
            this.listeners.splice(index, 1)
        }
    }

    /**
     * 通知所有监听器
     */
    notifyListeners() {
        this.listeners.forEach(listener => {
            try {
                listener(this.cartData)
            } catch (error) {
                console.error('购物车监听器执行失败:', error)
            }
        })
    }

    /**
     * 导出购物车数据（用于订单）
     */
    exportForOrder() {
        const selectedItems = this.getSelectedItems()
        if (selectedItems.length === 0) {
            throw new Error('请选择要结算的商品')
        }

        const orderData = {
            items: selectedItems.map(item => ({
                productId: item.id,
                goodsName: item.name,
                goodsPrice: item.goodsPrice,
                quantity: item.quantity,
                spec: item.spec,
                totalPrice: parseFloat((item.goodsPrice * item.quantity).toFixed(2)),
                serverId: item.serverId
            })),
            ...this.getSelectedTotals()
        }

        return orderData
    }

    /**
     * 获取网络状态
     */
    getNetworkStatus() {
        return {
            isOnline: this.isOnline,
            lastError: this.lastNetworkError
        }
    }
}

// 创建全局购物车管理器实例
const cartManager = new CartManager()

export default cartManager

/*
使用示例：

// 1. 添加商品到购物车（服务器优先）
try {
    await cartManager.addItem({
        id: '123',
        name: '测试商品',
        goodsPrice: 99.99,
        image: 'https://example.com/image.jpg'
    }, 2)
    console.log('添加成功')
} catch (error) {
    console.error('添加失败:', error.message)
}

// 2. 获取购物车数据（服务器优先）
try {
    const cartData = await cartManager.getCartData()
    console.log('购物车数据:', cartData)
} catch (error) {
    console.error('获取购物车数据失败:', error)
}

// 3. 获取购物车商品列表（服务器优先）
try {
    const items = await cartManager.getItems()
    console.log('商品列表:', items)
} catch (error) {
    console.error('获取商品列表失败:', error)
}

// 4. 更新商品数量（服务器优先）
try {
    await cartManager.updateQuantity('商品key', 3)
    console.log('更新成功')
} catch (error) {
    console.error('更新失败:', error)
}

// 5. 删除商品（服务器优先）
try {
    await cartManager.removeItem('商品key')
    console.log('删除成功')
} catch (error) {
    console.error('删除失败:', error)
}

// 6. 清空购物车（服务器优先）
try {
    await cartManager.clearCart()
    console.log('清空成功')
} catch (error) {
    console.error('清空失败:', error)
}

// 7. 获取网络状态
const networkStatus = cartManager.getNetworkStatus()
console.log('网络状态:', networkStatus.isOnline)
console.log('最后一次错误:', networkStatus.lastError)

// 8. 添加监听器，监听购物车变化
cartManager.addListener((cartData) => {
    console.log('购物车数据变化:', cartData)
    // 更新UI
})

// 9. 用户登录后同步数据
cartManager.onUserLogin()

// 10. 用户登出后清理数据
cartManager.onUserLogout()

// 11. 网络恢复后同步未同步的数据
cartManager.syncPendingData()
*/ 